package org.shoukaiseki.kakaroto;

import org.shoukaiseki.common.exception.MessageVirtualException;
import org.shoukaiseki.common.utils.StringUtils;
import org.shoukaiseki.kakaroto.Interface.DictTypeEnumData;
import org.shoukaiseki.kakaroto.annotation.DictTypeEnum;
import org.shoukaiseki.kakaroto.entity.BaseDictEnum;
import org.shoukaiseki.supersaiyan.common.core.domain.base.ISysDictData;
import org.shoukaiseki.supersaiyan.common.core.domain.SysDictData;
import org.shoukaiseki.supersaiyan.common.utils.spring.SpringUtils;
import org.shoukaiseki.supersaiyan.system.service.impl.SysDictTypeServiceImpl;
import org.springframework.core.annotation.AnnotationUtils;

import java.util.*;

/**
 *
 **/
public class SksDictUtils {


    public static final String YES_ZH="是";

    public static final String NO_ZH="否";


    //获取字典数据
    public static ISysDictData getDictData(List<?> dictList, String  dictValue){
        for (Object obj : dictList) {
            ISysDictData dict= (ISysDictData) obj;
            if (StringUtils.equals(dictValue,dict.getDictValue()))
            {
                return dict;
            }
        }
        return new SysDictData();
    }

    /**
     * 获取字典值对应的标签名
     * @param clazz         字典枚举类
     * @param dictValue     字典值
     * @return
     */
    public static String formatDictValue(Class<?> clazz,Object  dictValue){
        return formatDictValue(clazz,StringUtils.objToString(dictValue));
    }

    /**
     * 获取字典值对应的标签名
     * @param clazz         字典枚举类
     * @param dictValue     字典值
     * @return
     */
    public static String formatDictValue(Class<?> clazz,String  dictValue){
        return formatDictValue(getDictEnumTypeDictType(clazz),dictValue);
    }

    public static String formatDictValue(String dictType,String  dictValue){
        SysDictTypeServiceImpl sysDictTypeService = SpringUtils.getBean(SysDictTypeServiceImpl.class);
        List<SysDictData> list = sysDictTypeService.selectDictDataByType(dictType);
        if(StringUtils.isEmpty(list)){
            throw new MessageVirtualException("字典名称为'{}'的数据不存在,尝试初始化字典后重试").format(dictType);
        }
        String s = formatDictValue(list, dictValue);
        return s;

    }

    //获取字典数据
    public static String formatDictValue(List<?> dictList,String  dictValue){
        for (Object obj : dictList) {
            ISysDictData dict= (ISysDictData) obj;
            if (StringUtils.equals(dictValue,dict.getDictValue()))
            {
                return dict.getDictLabel();
            }
        }
        return StringUtils.NULLSTR;
    }

    //加急 0否1是
    public static String formatUrgentedNo0Yes1(String val){
        if (StringUtils.equalsStringOne(val)) {
            return YES_ZH;
        }
        return NO_ZH;
    }



    //获取字典信息用于 exportStructureExcel
    public static String getDictInfo(Class<?> clazz){
        StringBuilder tmp=new StringBuilder();
        Map<String, String> map = getDictEnumType(clazz);
        if(map!=null){
            tmp.append(map.get("dictType"))
                    .append("(").append(map.get("dictName")).append(")") ;
        }
        List<BaseDictEnum> list = getDictEnumDataList(clazz);
        StringJoiner sj=new StringJoiner(",","[","]");
        for (BaseDictEnum dictEnum : list) {
            StringBuilder sb=new StringBuilder();
            String value = dictEnum.getValueString();
            sb.append(value);
            sb.append(":");
            sb.append(dictEnum.getLabel());
            if (!StringUtils.isEmpty(dictEnum.getRemark())) {
                sb.append("(");
                sb.append(dictEnum.getRemark());
                sb.append(")");
            }
            sj.add(sb);
        }
        tmp.append(sj.toString());
        return tmp.toString();
    }

    /**
     * 获取字典名
     * @param clazz     字典枚举类
     * @return
     */
    public static String getDictEnumTypeDictType(Class<?> clazz){
        DictTypeEnum dictTypeEnum = AnnotationUtils.findAnnotation(clazz, DictTypeEnum.class);
        if(dictTypeEnum==null){
            return null;
        }
        String dictType = dictTypeEnum.dictType();
        return dictType;
    }

    //获取枚举的字典信息
    public static Map<String,String> getDictEnumType(Class<?> clazz){
        DictTypeEnum dictTypeEnum = AnnotationUtils.findAnnotation(clazz, DictTypeEnum.class);
        if(dictTypeEnum==null){
            return null;
        }
        String dictType = dictTypeEnum.dictType();
        HashMap<String,String> map = new HashMap<>();
        map.put("dictType",dictType);
        map.put("dictName",dictTypeEnum.dictName());
        map.put("remark",dictTypeEnum.remark());
        return map;
    }

    //字典枚举类转换为 value,label  的 map
    public static Map<String,String>  dictEnumToValueLabelMap(Class<?> clazz){
        HashMap<String,String> map = new HashMap<>();
        List<BaseDictEnum> dictEnumDataList = getDictEnumDataList(clazz);
        for (BaseDictEnum baseDictEnum : dictEnumDataList) {
            map.put(baseDictEnum.getValueString(),baseDictEnum.getLabel());
        }

        return map;
    }

    //获取枚举中的字典数据
    public static List<BaseDictEnum> getDictEnumDataList(Class<?> clazz){

        List<BaseDictEnum>  list=new ArrayList<>();
        for (Object anEnum : clazz.getEnumConstants()) {
            if(!(anEnum instanceof DictTypeEnumData)){
                throw new MessageVirtualException(anEnum.getClass().getSimpleName()+"需要继承DictTypeEnumData接口");
            }
            BaseDictEnum baseDictEnum = new BaseDictEnum();
            String valueString = ((DictTypeEnumData) anEnum).getValueString();
            baseDictEnum.setLabel(((DictTypeEnumData) anEnum).getLabel());
            baseDictEnum.setValue(valueString);
            baseDictEnum.setRemark(((DictTypeEnumData) anEnum).getRemark());

            list.add(baseDictEnum);
        }

        return list;
    }
}
